/*
Copyright (c) [2019年5月1日] [吴超]
[MBT_Studio] is licensed under Mulan PSL v2.
You can use this software according to the terms and conditions of the Mulan PSL v2.
You may obtain a copy of Mulan PSL v2 at:
		 http://license.coscl.org.cn/MulanPSL2
THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
See the Mulan PSL v2 for more details.
*/
#include "构建数据节点.h"


#include <节点/数据/数值变量.h>
#include <节点/数据/数据重组.h>
#include <节点/数据/体素数据.h>

static void on_属性改变更新节点(S_Props& prop) {
	//switch ((*(S_PropValueEnum*)prop.m_Value).m_当前选项)
	//((C_节点面板*)f_global_get激活节点())->m_NodeData->f_set是否要更新(true);
	auto nodes = f_global_get激活节点();
	for (auto n : nodes) {
		n->f_set是否要更新(true);
	}
}


static void on_属性改变更新节点_重新编译(S_Props& prop) {
	auto nodes = f_global_get激活节点();
	for (auto n : nodes) {
		n->f_更新上层节点(true);
	}
}

static void on_参数修改(S_Props& prop) {
	//switch ((*(S_PropValueEnum*)prop.m_Value).m_当前选项)
	auto nodes = f_global_get激活节点();
	for (auto 节点 : nodes) {
		节点->f_set是否要更新(true);
	}
}

static void on_参数修改_值设置(S_Props& prop) {
	auto nodes = f_global_get激活节点();
	for (auto 节点 : nodes) {
		C_单值浮点变量节点* node = (C_单值浮点变量节点*)节点;
		switch (f_prop_enum(node->m_常用量)) {
		case 0: f_prop_F32(node->m_值) = 3.1415926535; break;
		case 1: f_prop_F32(node->m_值) = 6.2831853071; break;
		case 2: f_prop_F32(node->m_值) = 1.5707963267; break;
		case 3: f_prop_F32(node->m_值) = 0.7853981633; break;
		}
		节点->f_set是否要更新(true);
	}
}

static void on_打开对话框_更新节点(S_Props& prop) {
	f_ui_set路径编辑框对话框类型(prop.m_UI->m_部件, E_对话框类型::e_打开路径);
	f_ui_set路径编辑框对话框后缀(prop.m_UI->m_部件, ".mesh");
	
	auto nodes = f_global_get激活节点();
	for (auto n : nodes) {
		n->f_set是否要更新(true);
	}
}





static void f_变量引用节点_部件构建属性(C_属性栏* plane, S_结构对象指针 obj) {
	C_单值浮点变量节点* node = dynamic_cast<C_单值浮点变量节点*>(((C_节点面板*)obj)->m_NodeData);

	std::vector<S_Props> props;
	f_节点重构_重构属性面板数据((C_节点面板*)obj, props);
	//S_Props prop;
	plane->f_构建属性部件(props);
}

C_节点面板* f_节点构建_变量引用(S_UI创建环境& ctx, S_设备环境& ctx_3d, C_节点基类* node, C_节点树* tree) {
	if (!node) node = new C_变量引用节点(ctx_3d);
	C_节点面板* plane = new C_节点面板(node, ctx, E_节点区类型::e_节点区_物体);
	f_节点重置_变量引用(plane, node);
	return plane;
}

void f_节点重置_变量引用(C_节点面板* plane, C_节点基类* node) {
	f_节点重构_面板重构(plane, node, E_节点区类型::e_节点区_节点视图);
	f_节点重构_插座重构(plane, node, E_节点区类型::e_节点区_节点视图);

	plane->m_属性面板参数构建 = f_变量引用节点_部件构建属性;
	plane->m_3D视口更新 = nullptr;
	plane->m_ICO = "die";
}



static void f_I8变量节点_部件构建属性(C_属性栏* plane, S_结构对象指针 obj) {
	C_I8变量节点* node = dynamic_cast<C_I8变量节点*>(((C_节点面板*)obj)->m_NodeData);

	std::vector<S_Props> props;
	f_节点重构_重构属性面板数据((C_节点面板*)obj, props);

	node->m_随机方式.m_UI->m_Update = on_属性改变更新节点;
	props.push_back(node->m_随机方式);

	node->m_初始值.m_UI->m_Update = on_属性改变更新节点;
	props.push_back(node->m_初始值);
	
	plane->f_构建属性部件(props);
}

C_节点面板* f_节点构建_I8变量(S_UI创建环境& ctx, S_设备环境& ctx_3d, C_节点基类* node, C_节点树* tree) {
	if (!node) {
		node = new C_I8变量节点(ctx_3d);
		node->m_ICO = "die";
	}
	C_节点面板* plane = new C_节点面板(node, ctx, E_节点区类型::e_节点区_物体);
	f_节点重置_I8变量(plane, node);
	return plane;
}

void f_节点重置_I8变量(C_节点面板* plane, C_节点基类* node) {
	f_节点重构_面板插座重构(plane, node, E_节点区类型::e_节点区_节点视图);
	plane->m_属性面板参数构建 = f_I8变量节点_部件构建属性;
	plane->m_ICO = node->m_ICO;
}



static void f_单值变量节点_部件构建属性(C_属性栏* plane, S_结构对象指针 obj) {
	//S_Props	prop = f_alloc_OpsProp(f_Operator初始化跟踪点, obj);
	//plane->m_属性.push_back(prop);
	//f_区管理_设置当前操作节点(((C_节点面板*)obj)->m_NodeData);
	C_单值浮点变量节点* node = dynamic_cast<C_单值浮点变量节点*>(((C_节点面板*)obj)->m_NodeData);

	std::vector<S_Props> props;
	f_节点重构_重构属性面板数据((C_节点面板*)obj, props);

	node->m_位数.m_UI->m_Update = on_属性改变更新节点;
	node->m_是否随机.m_UI->m_Update = on_属性改变更新节点;
	node->m_值.m_UI->m_Update = on_属性改变更新节点;
	props.push_back(node->m_位数);
	props.push_back(node->m_是否随机);
	props.push_back(node->m_值);

	node->m_常用量.m_UI->m_Update = on_参数修改_值设置;
	props.push_back(node->m_常用量);

	plane->f_构建属性部件(props);
}

C_节点面板* f_节点构建_单值浮点变量(S_UI创建环境& ctx, S_设备环境& ctx_3d, C_节点基类* node, C_节点树* tree) {
	if (!node) node = new C_单值浮点变量节点(ctx_3d);
	C_节点面板* plane = new C_节点面板(node, ctx, E_节点区类型::e_节点区_物体);
	f_节点重置_单值浮点变量(plane, node);
	return plane;
}

void f_节点重置_单值浮点变量(C_节点面板* plane, C_节点基类* node) {
	f_节点重构_面板重构(plane, node, E_节点区类型::e_节点区_节点视图);
	f_节点重构_插座重构(plane, node, E_节点区类型::e_节点区_节点视图);

	plane->m_属性面板参数构建 = f_单值变量节点_部件构建属性;
	plane->m_3D视口更新 = nullptr;
	plane->m_ICO = "die";
}





static void f_单值整数变量节点_部件构建属性(C_属性栏* plane, S_结构对象指针 obj) {
	C_单值整数变量节点* node = dynamic_cast<C_单值整数变量节点*>(((C_节点面板*)obj)->m_NodeData);

	std::vector<S_Props> props;
	f_节点重构_重构属性面板数据((C_节点面板*)obj, props);

	S_Props prop;
	props.push_back(node->m_位数);
	props.push_back(node->m_是否随机);
	props.push_back(node->m_值);

	node->m_位数.m_UI->m_Update = on_属性改变更新节点;
	node->m_是否随机.m_UI->m_Update = on_属性改变更新节点;
	node->m_值.m_UI->m_Update = on_属性改变更新节点;

	plane->f_构建属性部件(props);

}

C_节点面板* f_节点构建_单值整数变量(S_UI创建环境& ctx, S_设备环境& ctx_3d, C_节点基类* node, C_节点树* tree) {
	if (!node) node = new C_单值整数变量节点(ctx_3d);
	//if (plane == nullptr) {
	//	plane = f_节点创建_UI面板构建(ctx, node, E_节点区类型::e_节点区_节点视图);
	//}
	C_节点面板* plane = new C_节点面板(node, ctx, E_节点区类型::e_节点区_物体);
	f_节点重置_单值整数变量(plane, node);
	return plane;
}

void		f_节点重置_单值整数变量(C_节点面板* plane, C_节点基类* node) {
	f_节点重构_面板重构(plane, node, E_节点区类型::e_节点区_节点视图);
	f_节点重构_插座重构(plane, node, E_节点区类型::e_节点区_节点视图);

	plane->m_属性面板参数构建 = f_单值整数变量节点_部件构建属性;
	plane->m_3D视口更新 = nullptr;
	plane->m_ICO = "die";
}




static void f_无符号整数变量节点_部件构建属性(C_属性栏* plane, S_结构对象指针 obj) {
	C_无符号整数变量节点* node = dynamic_cast<C_无符号整数变量节点*>(((C_节点面板*)obj)->m_NodeData);

	std::vector<S_Props> props;
	f_节点重构_重构属性面板数据((C_节点面板*)obj, props);

	S_Props prop;
	node->m_位数.m_UI->m_Update = on_属性改变更新节点;
	props.push_back(node->m_位数);
	
	node->m_是否随机.m_UI->m_Update = on_属性改变更新节点;
	props.push_back(node->m_是否随机);
	
	node->m_值.m_UI->m_Update = on_属性改变更新节点;
	props.push_back(node->m_值);

	node->m_标志位.m_UI->m_Update = on_属性改变更新节点;
	props.push_back(node->m_标志位);

	plane->f_构建属性部件(props);
}

C_节点面板* f_节点构建_无符号整数变量(S_UI创建环境& ctx, S_设备环境& ctx_3d, C_节点基类* node, C_节点树* tree) {
	if (!node) {
		node = new C_无符号整数变量节点(ctx_3d);
		node->m_ICO = "icoVec3_1D0006";
	}
	C_节点面板* plane = new C_节点面板(node, ctx, E_节点区类型::e_节点区_物体);
	f_节点重置_无符号整数变量(plane, node);
	return plane;
}

void f_节点重置_无符号整数变量(C_节点面板* plane, C_节点基类* node) {
	f_节点重构_面板插座重构(plane, node, E_节点区类型::e_节点区_节点视图);
	plane->m_属性面板参数构建 = f_无符号整数变量节点_部件构建属性;
	plane->m_ICO = node->m_ICO;
}










static void f_线段变量节点_部件构建属性(C_属性栏* plane, S_结构对象指针 obj) {
	C_线段数据节点* node = dynamic_cast<C_线段数据节点*>(((C_节点面板*)obj)->m_NodeData);

	std::vector<S_Props> props;
	f_节点重构_重构属性面板数据((C_节点面板*)obj, props);

	S_Props prop;
	/*props.push_back(node->m_位数);
	props.push_back(node->m_是否随机);
	props.push_back(node->m_值);

	node->m_位数.m_UI->m_Update = on_属性改变更新节点;
	node->m_是否随机.m_UI->m_Update = on_属性改变更新节点;
	node->m_值.m_UI->m_Update = on_属性改变更新节点;*/

	for (auto& e : props) {
		e.m_UI->m_Update = on_参数修改;
	}

	plane->f_构建属性部件(props);
}

C_节点面板* f_节点构建_线段变量(S_UI创建环境& ctx, S_设备环境& ctx_3d, C_节点基类* node, C_节点树* tree) {
	if (!node) node = new C_线段数据节点(ctx_3d);
	//if (plane == nullptr) {
	//	plane = f_节点创建_UI面板构建(ctx, node, E_节点区类型::e_节点区_节点视图);
	//}
	C_节点面板* plane = new C_节点面板(node, ctx, E_节点区类型::e_节点区_物体);
	f_节点重置_线段变量(plane, node);
	return plane;
}

void f_节点重置_线段变量(C_节点面板* plane, C_节点基类* node) {
	f_节点重构_面板重构(plane, node, E_节点区类型::e_节点区_节点视图);
	f_节点重构_插座重构(plane, node, E_节点区类型::e_节点区_节点视图);

	plane->m_属性面板参数构建 = f_线段变量节点_部件构建属性;
	plane->m_3D视口更新 = nullptr;
	plane->m_ICO = "die";
}



static void f_vec2变量节点_部件构建属性(C_属性栏* plane, S_结构对象指针 obj) {
	C_vec2变量节点* node = dynamic_cast<C_vec2变量节点*>(((C_节点面板*)obj)->m_NodeData);

	std::vector<S_Props> props;
	f_节点重构_重构属性面板数据((C_节点面板*)obj, props);
	node->m_是否随机.m_UI->m_Update = on_属性改变更新节点;
	props.push_back(node->m_是否随机);
	plane->f_构建属性部件(props);
}

C_节点面板* f_节点构建_vec2变量(S_UI创建环境& ctx, S_设备环境& ctx_3d, C_节点基类* node, C_节点树* tree) {
	if (!node) node = new C_vec2变量节点(ctx_3d);
	C_节点面板* plane = new C_节点面板(node, ctx, E_节点区类型::e_节点区_物体);
	f_节点重置_vec2变量(plane, node);
	return plane;
}

void f_节点重置_vec2变量(C_节点面板* plane, C_节点基类* node) {
	f_节点重构_面板重构(plane, node, E_节点区类型::e_节点区_节点视图);
	f_节点重构_插座重构(plane, node, E_节点区类型::e_节点区_节点视图);

	plane->m_属性面板参数构建 = f_vec2变量节点_部件构建属性;
	plane->m_3D视口更新 = nullptr;
	plane->m_ICO = "die";
}



static void f_I8数组变量节点_部件构建属性(C_属性栏* plane, S_结构对象指针 obj) {
	C_I8数组变量节点* node = dynamic_cast<C_I8数组变量节点*>(((C_节点面板*)obj)->m_NodeData);

	std::vector<S_Props> props;
	f_节点重构_重构属性面板数据((C_节点面板*)obj, props);
	node->m_随机方式.m_UI->m_Update = on_属性改变更新节点;
	props.push_back(node->m_随机方式);
	plane->f_构建属性部件(props);
}

C_节点面板* f_节点构建_I8数组变量(S_UI创建环境& ctx, S_设备环境& ctx_3d, C_节点基类* node, C_节点树* tree) {
	if (!node) {
		node = new C_I8数组变量节点(ctx_3d);
		node->m_ICO = "die";
	}
	C_节点面板* plane = new C_节点面板(node, ctx, E_节点区类型::e_节点区_物体);
	f_节点重置_I8数组变量(plane, node);
	return plane;
}

void f_节点重置_I8数组变量(C_节点面板* plane, C_节点基类* node) {
	f_节点重构_面板插座重构(plane, node, E_节点区类型::e_节点区_节点视图);
	plane->m_属性面板参数构建 = f_I8数组变量节点_部件构建属性;
	plane->m_ICO = node->m_ICO;
}



static void f_F32变量节点_部件构建属性(C_属性栏* plane, S_结构对象指针 obj) {
	C_F32数组变量节点* node = dynamic_cast<C_F32数组变量节点*>(((C_节点面板*)obj)->m_NodeData);

	std::vector<S_Props> props;
	f_节点重构_重构属性面板数据((C_节点面板*)obj, props);
	node->m_随机方式.m_UI->m_Update = on_属性改变更新节点;
	props.push_back(node->m_随机方式);
	plane->f_构建属性部件(props);
}

C_节点面板* f_节点构建_F32数组变量(S_UI创建环境& ctx, S_设备环境& ctx_3d, C_节点基类* node, C_节点树* tree) {
	if (!node) {
		node = new C_F32数组变量节点(ctx_3d);
		node->m_ICO = "die";
	}
	C_节点面板* plane = new C_节点面板(node, ctx, E_节点区类型::e_节点区_物体);
	f_节点重置_F32数组变量(plane, node);
	return plane;
}

void f_节点重置_F32数组变量(C_节点面板* plane, C_节点基类* node) {
	f_节点重构_面板插座重构(plane, node, E_节点区类型::e_节点区_节点视图);
	plane->m_属性面板参数构建 = f_F32变量节点_部件构建属性;
	plane->m_3D视口更新 = nullptr;
	plane->m_ICO = node->m_ICO;
}




static void f_I32数组变量构建节点_部件构建属性(C_属性栏* plane, S_结构对象指针 obj) {
	C_I32数组变量节点* node = dynamic_cast<C_I32数组变量节点*>(((C_节点面板*)obj)->m_NodeData);
	std::vector<S_Props> props;
	f_节点重构_重构属性面板数据((C_节点面板*)obj, props);

	node->m_随机方式.m_UI->m_Update = on_属性改变更新节点;
	props.push_back(node->m_随机方式);

	plane->f_构建属性部件(props);
}

C_节点面板* f_节点构建_I32数组变量构建(S_UI创建环境& ctx, S_设备环境& ctx_3d, C_节点基类* node, C_节点树* tree) {
	if (!node) {
		node = new C_I32数组变量节点(ctx_3d);
		node->m_ICO = "icoVec3_1D0006";
	}
	C_节点面板* plane = new C_节点面板(node, ctx, E_节点区类型::e_节点区_物体);
	f_节点重置_I32数组变量构建(plane, node);
	return plane;
}

void f_节点重置_I32数组变量构建(C_节点面板* plane, C_节点基类* node) {
	f_节点重构_面板插座重构(plane, node, E_节点区类型::e_节点区_节点视图);
	plane->m_属性面板参数构建 = f_I32数组变量构建节点_部件构建属性;
	plane->m_ICO = node->m_ICO;
}



static void f_UI32数组变量构建节点_部件构建属性(C_属性栏* plane, S_结构对象指针 obj) {
	C_UI32数组变量节点* node = dynamic_cast<C_UI32数组变量节点*>(((C_节点面板*)obj)->m_NodeData);
	std::vector<S_Props> props;
	f_节点重构_重构属性面板数据((C_节点面板*)obj, props);

	node->m_随机方式.m_UI->m_Update = on_属性改变更新节点;
	props.push_back(node->m_随机方式);

	node->m_值.m_UI->m_Update = on_属性改变更新节点;
	props.push_back(node->m_值);

	plane->f_构建属性部件(props);
}

C_节点面板* f_节点构建_UI32数组变量构建(S_UI创建环境& ctx, S_设备环境& ctx_3d, C_节点基类* node, C_节点树* tree) {
	if (!node) {
		node = new C_UI32数组变量节点(ctx_3d);
		node->m_ICO = "icoVec3_1D0006";
	}
	C_节点面板* plane = new C_节点面板(node, ctx, E_节点区类型::e_节点区_物体);
	f_节点重置_UI32数组变量构建(plane, node);
	return plane;
}

void f_节点重置_UI32数组变量构建(C_节点面板* plane, C_节点基类* node) {
	f_节点重构_面板插座重构(plane, node, E_节点区类型::e_节点区_节点视图);
	plane->m_属性面板参数构建 = f_UI32数组变量构建节点_部件构建属性;
	plane->m_ICO = node->m_ICO;
}




static void f_矩阵数组变量节点_部件构建属性(C_属性栏* plane, S_结构对象指针 obj) {
	C_矩阵数组变量节点* node = dynamic_cast<C_矩阵数组变量节点*>(((C_节点面板*)obj)->m_NodeData);

	std::vector<S_Props> props;
	f_节点重构_重构属性面板数据((C_节点面板*)obj, props);

	//props.push_back(f_alloc_UI32Prop(DEF_UI32插座数据(node->f_get输入插座(1)), L"数组大小"));

	plane->f_构建属性部件(props);

}

C_节点面板* f_节点构建_矩阵数组变量(S_UI创建环境& ctx, S_设备环境& view_ctx, C_节点基类* node, C_节点树* tree) {
	if (!node) node = new C_矩阵数组变量节点(*S_框架::g_3D视口环境);
	//if (plane == nullptr) {
	//	plane = f_节点创建_UI面板构建(ctx, node, E_节点区类型::e_节点区_物体);
	//}
	C_节点面板* plane = new C_节点面板(node, ctx, E_节点区类型::e_节点区_物体);
	f_节点重置_矩阵数组变量(plane, node);
	return plane;
}

void f_节点重置_矩阵数组变量(C_节点面板* plane, C_节点基类* node) {
	f_节点重构_面板重构(plane, node, E_节点区类型::e_节点区_节点视图);
	f_节点重构_插座重构(plane, node, E_节点区类型::e_节点区_节点视图);

	plane->m_属性面板参数构建 = f_矩阵数组变量节点_部件构建属性;
	plane->m_3D视口更新 = nullptr;
	plane->m_ICO = "stack";
}











static void f_vec3变量_3D视口更新(C_节点面板* n, S_Scene* scene) {
	C_vec3变量节点* node = dynamic_cast<C_vec3变量节点*>(n->m_NodeData);
}

static void f_vec3变量_部件构建属性(C_属性栏* plane, S_结构对象指针 obj) {
	C_vec3变量节点* node = dynamic_cast<C_vec3变量节点*>(((C_节点面板*)obj)->m_NodeData);

	std::vector<S_Props> props;
	f_节点重构_重构属性面板数据((C_节点面板*)obj, props);
	//props.push_back(prop);
	//props.push_back(f_alloc_Vec3Prop(DEF_Vec3插座数据(node->f_get输出插座(1)), L"值"));
	node->m_是否随机.m_UI->m_Update = on_属性改变更新节点;
	props.push_back(node->m_是否随机);
	node->m_Value.m_UI->m_Update = on_属性改变更新节点;
	props.push_back(node->m_Value);

	plane->f_构建属性部件(props);

	f_vec3变量_3D视口更新(((C_节点面板*)obj), nullptr);
}

C_节点面板* f_节点构建_vec3变量(S_UI创建环境& ctx, S_设备环境& view_ctx, C_节点基类* node, C_节点树* tree) {
	if (!node) node = new C_vec3变量节点(view_ctx);
	//if (plane == nullptr) {
	//	plane = f_节点创建_UI面板构建(ctx, node, E_节点区类型::e_节点区_节点视图);
	//}
	C_节点面板* plane = new C_节点面板(node, ctx, E_节点区类型::e_节点区_物体);
	f_节点重置_vec3变量(plane, node);

	return plane;
}

void f_节点重置_vec3变量(C_节点面板* plane, C_节点基类* node) {
	C_vec3变量节点* v = dynamic_cast<C_vec3变量节点*>(node);

	f_节点重构_面板重构(plane, node, E_节点区类型::e_节点区_节点视图);
	f_节点重构_插座重构(plane, node, E_节点区类型::e_节点区_节点视图);

	plane->m_属性面板参数构建 = f_vec3变量_部件构建属性;
	plane->m_3D视口更新 = nullptr;
	plane->m_ICO = "icoVec3_1D0006";
}



static void f_ivec3变量_部件构建属性(C_属性栏* plane, S_结构对象指针 obj) {
	C_ivec3变量节点* node = dynamic_cast<C_ivec3变量节点*>(((C_节点面板*)obj)->m_NodeData);

	std::vector<S_Props> props;
	f_节点重构_重构属性面板数据((C_节点面板*)obj, props);
	
	node->m_是否随机.m_UI->m_Update = on_属性改变更新节点;
	props.push_back(node->m_是否随机);
	node->m_Value.m_UI->m_Update = on_属性改变更新节点;
	props.push_back(node->m_Value);

	plane->f_构建属性部件(props);

	f_vec3变量_3D视口更新(((C_节点面板*)obj), nullptr);
}

C_节点面板* f_节点构建_ivec3变量(S_UI创建环境& ctx, S_设备环境& ctx_3d, C_节点基类* node, C_节点树* tree) {
	if (!node) {
		node = new C_ivec3变量节点(ctx_3d);
		node->m_ICO = "icoVec3_1D0006";
	}
	C_节点面板* plane = new C_节点面板(node, ctx, E_节点区类型::e_节点区_物体);
	f_节点重置_ivec3变量(plane, node);
	return plane;
}

void f_节点重置_ivec3变量(C_节点面板* plane, C_节点基类* node) {
	f_节点重构_面板插座重构(plane, node, E_节点区类型::e_节点区_节点视图);
	plane->m_属性面板参数构建 = f_ivec3变量_部件构建属性;
	plane->m_ICO = node->m_ICO;
}



static void f_vec2数组变量节点_部件构建属性(C_属性栏* plane, S_结构对象指针 obj) {
	C_vec2数组变量节点* node = dynamic_cast<C_vec2数组变量节点*>(((C_节点面板*)obj)->m_NodeData);

	std::vector<S_Props> props;
	f_节点重构_重构属性面板数据((C_节点面板*)obj, props);
	//props.push_back(f_alloc_UI64Prop(&DEF_UI64插座Value(node->f_get输入插座(1), 0), L"数组大小"));
	//props.push_back(f_alloc_I32Prop(&DEF_I32插座Value(node->f_get输入插座(2), 0), L"随机种子"));
	//props.push_back(f_alloc_Vec2Prop(&DEF_Vec2插座数据(node->f_get输入插座(3), 0), L"最小范围"));
	//props.push_back(f_alloc_Vec2Prop(&DEF_Vec2插座数据(node->f_get输入插座(4), 0), L"最大范围"));
	node->m_是否随机.m_UI->m_Update = on_属性改变更新节点;
	props.push_back(node->m_是否随机);

	plane->f_构建属性部件(props);
}

C_节点面板* f_节点构建_vec2数组变量(S_UI创建环境& ctx, S_设备环境& view_ctx, C_节点基类* node, C_节点树* tree) {
	if (!node) node = new C_vec2数组变量节点(view_ctx);
	//if (plane == nullptr) {
	//	plane = f_节点创建_UI面板构建(ctx, node, E_节点区类型::e_节点区_节点视图);
	//}
	C_节点面板* plane = new C_节点面板(node, ctx, E_节点区类型::e_节点区_物体);
	f_节点重置_vec2数组变量(plane, node);

	return plane;
}

void		f_节点重置_vec2数组变量(C_节点面板* plane, C_节点基类* node) {
	//C_vec2数组变量节点* v = dynamic_cast<C_vec2数组变量节点*>(node);
	f_节点重构_面板重构(plane, node, E_节点区类型::e_节点区_节点视图);
	f_节点重构_插座重构(plane, node, E_节点区类型::e_节点区_节点视图);

	plane->m_属性面板参数构建 = f_vec2数组变量节点_部件构建属性;
	plane->m_3D视口更新 = nullptr;
	plane->m_ICO = "stack";
}








static void f_vec3数组变量节点_部件构建属性(C_属性栏* plane, S_结构对象指针 obj) {
	C_vec3数组变量节点* node = dynamic_cast<C_vec3数组变量节点*>(((C_节点面板*)obj)->m_NodeData);

	std::vector<S_Props> props;
	f_节点重构_重构属性面板数据((C_节点面板*)obj, props);
	//props.push_back(f_alloc_UI64Prop(&DEF_UI64插座Value(node->f_get输入插座(1), 0), L"数组大小"));
	//props.push_back(f_alloc_I32Prop(&DEF_I32插座Value(node->f_get输入插座(2), 0), L"随机种子"));
	//props.push_back(f_alloc_Vec2Prop(&DEF_Vec2插座数据(node->f_get输入插座(3), 0), L"随机范围"));
	node->m_是否随机.m_UI->m_Update = on_属性改变更新节点;
	props.push_back(node->m_是否随机);

	//for (auto& e : props) {
	//	e.m_UI->m_Update = on_参数修改;
	//}

	plane->f_构建属性部件(props);
}

C_节点面板* f_节点构建_vec3数组变量(S_UI创建环境& ctx, S_设备环境& ctx_3d, C_节点基类* node, C_节点树* tree) {
	if (!node) {
		node = new C_vec3数组变量节点(ctx_3d);
		node->m_ICO = "icoVec3_1D0006";
	}
	C_节点面板* plane = new C_节点面板(node, ctx, E_节点区类型::e_节点区_物体);
	f_节点重置_vec3数组变量(plane, node);
	return plane;
}

void f_节点重置_vec3数组变量(C_节点面板* plane, C_节点基类* node) {
	f_节点重构_面板插座重构(plane, node, E_节点区类型::e_节点区_节点视图);
	plane->m_属性面板参数构建 = f_vec3数组变量节点_部件构建属性;
	plane->m_ICO = node->m_ICO;
}



static void f_ivec2数组变量节点_部件构建属性(C_属性栏* plane, S_结构对象指针 obj) {
	C_ivec2数组变量节点* node = dynamic_cast<C_ivec2数组变量节点*>(((C_节点面板*)obj)->m_NodeData);

	std::vector<S_Props> props;
	f_节点重构_重构属性面板数据((C_节点面板*)obj, props);

	node->m_填充方式.m_UI->m_Update = on_属性改变更新节点;
	props.push_back(node->m_填充方式);

	plane->f_构建属性部件(props);
}

C_节点面板* f_节点构建_ivec2数组变量(S_UI创建环境& ctx, S_设备环境& ctx_3d, C_节点基类* node, C_节点树* tree) {
	if (!node) {
		node = new C_ivec2数组变量节点(ctx_3d);
		node->m_ICO = "icoVec3_1D0006";
	}
	C_节点面板* plane = new C_节点面板(node, ctx, E_节点区类型::e_节点区_物体);
	f_节点重置_ivec2数组变量(plane, node);
	return plane;
}

void f_节点重置_ivec2数组变量(C_节点面板* plane, C_节点基类* node) {
	f_节点重构_面板插座重构(plane, node, E_节点区类型::e_节点区_节点视图);
	plane->m_属性面板参数构建 = f_ivec2数组变量节点_部件构建属性;
	plane->m_ICO = node->m_ICO;
}



static void f_ivec3数组变量节点_部件构建属性(C_属性栏* plane, S_结构对象指针 obj) {
	C_ivec3数组变量节点* node = dynamic_cast<C_ivec3数组变量节点*>(((C_节点面板*)obj)->m_NodeData);

	std::vector<S_Props> props;
	f_节点重构_重构属性面板数据((C_节点面板*)obj, props);

	node->m_是否随机.m_UI->m_Update = on_属性改变更新节点;
	props.push_back(node->m_是否随机);

	node->m_是否无符号.m_UI->m_Update = on_属性改变更新节点_重新编译;
	props.push_back(node->m_是否无符号);
	
	plane->f_构建属性部件(props);
}

C_节点面板* f_节点构建_ivec3数组变量(S_UI创建环境& ctx, S_设备环境& ctx_3d, C_节点基类* node, C_节点树* tree) {
	if (!node) {
		node = new C_ivec3数组变量节点(ctx_3d);
		node->m_ICO = "icoVec3_1D0006";
	}
	C_节点面板* plane = new C_节点面板(node, ctx, E_节点区类型::e_节点区_物体);
	f_节点重置_ivec3数组变量(plane, node);
	return plane;
}

void f_节点重置_ivec3数组变量(C_节点面板* plane, C_节点基类* node) {
	f_节点重构_面板插座重构(plane, node, E_节点区类型::e_节点区_节点视图);
	plane->m_属性面板参数构建 = f_ivec3数组变量节点_部件构建属性;
	plane->m_ICO = node->m_ICO;
}



static void f_vec4数组变量节点_部件构建属性(C_属性栏* plane, S_结构对象指针 obj) {
	C_Vec4数组节点* node = dynamic_cast<C_Vec4数组节点*>(((C_节点面板*)obj)->m_NodeData);
	std::vector<S_Props> props;
	f_节点重构_重构属性面板数据((C_节点面板*)obj, props);
	node->m_是否随机.m_UI->m_Update = on_属性改变更新节点;
	props.push_back(node->m_是否随机);
	plane->f_构建属性部件(props);
}

C_节点面板* f_节点构建_vec4数组变量(S_UI创建环境& ctx, S_设备环境& ctx_3d, C_节点基类* node, C_节点树* tree) {
	if (!node) {
		node = new C_Vec4数组节点(ctx_3d);
		node->m_ICO = "icoVec3_1D0006";
	}
	C_节点面板* plane = new C_节点面板(node, ctx, E_节点区类型::e_节点区_物体);
	f_节点重置_vec4数组变量(plane, node);
	return plane;
}

void f_节点重置_vec4数组变量(C_节点面板* plane, C_节点基类* node) {
	f_节点重构_面板插座重构(plane, node, E_节点区类型::e_节点区_节点视图);
	plane->m_属性面板参数构建 = f_vec4数组变量节点_部件构建属性;
	plane->m_ICO = node->m_ICO;
}











static void f_矩阵构建节点_部件构建属性(C_属性栏* plane, S_结构对象指针 obj) {
	C_矩阵构建节点* node = dynamic_cast<C_矩阵构建节点*>(((C_节点面板*)obj)->m_NodeData);

	std::vector<S_Props> props;
	f_节点重构_重构属性面板数据((C_节点面板*)obj, props);


	node->m_矩阵类型.m_UI->m_Update = on_属性改变更新节点;
	node->m_轴向.m_UI->m_Update = on_属性改变更新节点;
	node->m_方向.m_UI->m_Update = on_属性改变更新节点;
	node->m_角度.m_UI->m_Update = on_属性改变更新节点;

	props.push_back(node->m_矩阵类型);
	props.push_back(node->m_轴向);
	props.push_back(node->m_方向);
	props.push_back(node->m_角度);

	plane->f_构建属性部件(props);
}

C_节点面板* f_节点构建_矩阵构建(S_UI创建环境& ctx, S_设备环境& dev_ctx, C_节点基类* node, C_节点树* tree) {
	if (!node) node = new C_矩阵构建节点(dev_ctx);
	//if (nullptr == plane) {
	//	plane = f_节点创建_UI面板构建(ctx, node, E_节点区类型::e_节点区_节点视图);
	//}
	C_节点面板* plane = new C_节点面板(node, ctx, E_节点区类型::e_节点区_物体);
	f_节点重置_矩阵构建(plane, node);

	return plane;
}

void f_节点重置_矩阵构建(C_节点面板* plane, C_节点基类* node) {
	f_节点重构_面板重构(plane, node, E_节点区类型::e_节点区_节点视图);
	f_节点重构_插座重构(plane, node, E_节点区类型::e_节点区_节点视图);

	plane->m_属性面板参数构建 = f_矩阵构建节点_部件构建属性;
	plane->m_ICO = "icoVec3_1D0006";
}




static void f_坐标构建平面节点_部件构建属性(C_属性栏* plane, S_结构对象指针 obj) {
	C_坐标构建平面节点* node = dynamic_cast<C_坐标构建平面节点*>(((C_节点面板*)obj)->m_NodeData);

	std::vector<S_Props> props;
	f_节点重构_重构属性面板数据((C_节点面板*)obj, props);
	plane->f_构建属性部件(props);
}

C_节点面板* f_节点构建_平面变量(S_UI创建环境& ctx, S_设备环境& ctx_3d, C_节点基类* node, C_节点树* tree) {
	if (!node) {
		node = new C_坐标构建平面节点(ctx_3d);
		node->m_ICO = "icoVec3_1D0006";
	}
	C_节点面板* plane = new C_节点面板(node, ctx, E_节点区类型::e_节点区_物体);
	f_节点重置_平面变量(plane, node);
	return plane;
}

void f_节点重置_平面变量(C_节点面板* plane, C_节点基类* node) {
	f_节点重构_面板插座重构(plane, node, E_节点区类型::e_节点区_节点视图);
	plane->m_属性面板参数构建 = f_坐标构建平面节点_部件构建属性;
	plane->m_ICO = node->m_ICO;
}



static void f_线段1D变量节点_部件构建属性(C_属性栏* plane, S_结构对象指针 obj) {
	C_线段1D数据节点* node = dynamic_cast<C_线段1D数据节点*>(((C_节点面板*)obj)->m_NodeData);
	std::vector<S_Props> props;
	f_节点重构_重构属性面板数据((C_节点面板*)obj, props);
	//node->m_组合类型.m_UI->m_Update = on_属性改变更新节点;
	props.push_back(node->m_组合类型);

	for (auto& e : props) {
		e.m_UI->m_Update = on_参数修改;
	}
	plane->f_构建属性部件(props);
}

C_节点面板* f_节点构建_线段1D变量(S_UI创建环境& ctx, S_设备环境& dev_ctx, C_节点基类* node, C_节点树* tree) {
	if (!node) node = new C_线段1D数据节点(dev_ctx);
	//if (nullptr == plane) {
	//	plane = f_节点创建_UI面板构建(ctx, node, E_节点区类型::e_节点区_节点视图);
	//}
	C_节点面板* plane = new C_节点面板(node, ctx, E_节点区类型::e_节点区_物体);
	f_节点重置_线段1D变量(plane, node);
	return plane;
}

void f_节点重置_线段1D变量(C_节点面板* plane, C_节点基类* node) {
	f_节点重构_面板重构(plane, node, E_节点区类型::e_节点区_节点视图);
	f_节点重构_插座重构(plane, node, E_节点区类型::e_节点区_节点视图);

	plane->m_属性面板参数构建 = f_线段1D变量节点_部件构建属性;
	plane->m_ICO = "icoVec3_1D0006";
}




static void f_观察矩阵构建节点_部件构建属性(C_属性栏* plane, S_结构对象指针 obj) {
	C_观察矩阵构建节点* node = dynamic_cast<C_观察矩阵构建节点*>(((C_节点面板*)obj)->m_NodeData);
	std::vector<S_Props> props;
	f_节点重构_重构属性面板数据((C_节点面板*)obj, props);

	node->m_翻转.m_UI->m_Update = on_属性改变更新节点;
	props.push_back(node->m_翻转);

	plane->f_构建属性部件(props);
}

C_节点面板* f_节点构建_观察矩阵构建(S_UI创建环境& ctx, S_设备环境& ctx_3d, C_节点基类* node, C_节点树* tree) {
	if (!node) node = new C_观察矩阵构建节点(ctx_3d);
	C_节点面板* plane = new C_节点面板(node, ctx, E_节点区类型::e_节点区_物体);
	f_节点重置_观察矩阵构建(plane, node);
	return plane;
}

void f_节点重置_观察矩阵构建(C_节点面板* plane, C_节点基类* node) {
	f_节点重构_面板重构(plane, node, E_节点区类型::e_节点区_节点视图);
	f_节点重构_插座重构(plane, node, E_节点区类型::e_节点区_节点视图);

	plane->m_属性面板参数构建 = f_观察矩阵构建节点_部件构建属性;
	plane->m_ICO = "icoVec3_1D0006";
}




static void f_数组变量节点_部件构建属性(C_属性栏* plane, S_结构对象指针 obj) {
	C_数组变量节点* node = dynamic_cast<C_数组变量节点*>(((C_节点面板*)obj)->m_NodeData);
	std::vector<S_Props> props;
	f_节点重构_重构属性面板数据((C_节点面板*)obj, props);

	node->m_元素类型.m_UI->m_Update = on_属性改变更新节点_重新编译;
	props.push_back(node->m_元素类型);

	plane->f_构建属性部件(props);
}

C_节点面板* f_节点构建_数组变量(S_UI创建环境& ctx, S_设备环境& ctx_3d, C_节点基类* node, C_节点树* tree) {
	if (!node) node = new C_数组变量节点(ctx_3d);
	C_节点面板* plane = new C_节点面板(node, ctx, E_节点区类型::e_节点区_物体);
	f_节点重置_数组变量(plane, node);
	return plane;
}
void f_节点重置_数组变量(C_节点面板* plane, C_节点基类* node) {
	f_节点重构_面板插座重构(plane, node, E_节点区类型::e_节点区_节点视图);
	plane->m_属性面板参数构建 = f_数组变量节点_部件构建属性;
	plane->m_ICO = "icoVec3_1D0006";
}





static void f_多边形成员数组变量节点_部件构建属性(C_属性栏* plane, S_结构对象指针 obj) {
	C_多边形成员数组变量节点* node = dynamic_cast<C_多边形成员数组变量节点*>(((C_节点面板*)obj)->m_NodeData);
	std::vector<S_Props> props;
	f_节点重构_重构属性面板数据((C_节点面板*)obj, props);

	node->m_成员.m_UI->m_Update = on_属性改变更新节点_重新编译;
	props.push_back(node->m_成员);

	node->m_维度.m_UI->m_Update = on_属性改变更新节点_重新编译;
	props.push_back(node->m_维度);

	plane->f_构建属性部件(props);
}

C_节点面板* f_节点构建_多边形成员数组变量(S_UI创建环境& ctx, S_设备环境& ctx_3d, C_节点基类* node, C_节点树* tree) {
	if (!node) {
		node = new C_多边形成员数组变量节点(ctx_3d);
		node->m_ICO = "icoVec3_1D0006";
	}
	C_节点面板* plane = new C_节点面板(node, ctx, E_节点区类型::e_节点区_物体);
	f_节点重置_多边形成员数组变量(plane, node);
	return plane;
}

void f_节点重置_多边形成员数组变量(C_节点面板* plane, C_节点基类* node) {
	f_节点重构_面板插座重构(plane, node, E_节点区类型::e_节点区_节点视图);
	plane->m_属性面板参数构建 = f_多边形成员数组变量节点_部件构建属性;
	plane->m_ICO = node->m_ICO;
}



static void f_数组添加元素节点_部件构建属性(C_属性栏* plane, S_结构对象指针 obj) {
	C_数组添加元素节点* node = dynamic_cast<C_数组添加元素节点*>(((C_节点面板*)obj)->m_NodeData);
	std::vector<S_Props> props;
	f_节点重构_重构属性面板数据((C_节点面板*)obj, props);

	node->m_添加方式.m_UI->m_Update = on_属性改变更新节点;
	props.push_back(node->m_添加方式);

	plane->f_构建属性部件(props);
}
C_节点面板* f_节点构建_数组添加元素(S_UI创建环境& ctx, S_设备环境& ctx_3d, C_节点基类* node, C_节点树* tree) {
	if (!node) node = new C_数组添加元素节点(ctx_3d);
	C_节点面板* plane = new C_节点面板(node, ctx, E_节点区类型::e_节点区_物体);
	f_节点重置_数组添加元素(plane, node);
	return plane;
}
void f_节点重置_数组添加元素(C_节点面板* plane, C_节点基类* node) {
	f_节点重构_面板重构(plane, node, E_节点区类型::e_节点区_节点视图);
	f_节点重构_插座重构(plane, node, E_节点区类型::e_节点区_节点视图);

	plane->m_属性面板参数构建 = f_数组添加元素节点_部件构建属性;
	plane->m_ICO = "icoVec3_1D0006";
}




static void f_数组属性节点_部件构建属性(C_属性栏* plane, S_结构对象指针 obj) {
	C_取数组属性节点* node = dynamic_cast<C_取数组属性节点*>(((C_节点面板*)obj)->m_NodeData);
	std::vector<S_Props> props;
	f_节点重构_重构属性面板数据((C_节点面板*)obj, props);

	plane->f_构建属性部件(props);
}

C_节点面板* f_节点构建_数组属性(S_UI创建环境& ctx, S_设备环境& ctx_3d, C_节点基类* node, C_节点树* tree) {
	if (!node) node = new C_取数组属性节点(ctx_3d);
	C_节点面板* plane = new C_节点面板(node, ctx, E_节点区类型::e_节点区_物体);
	f_节点重置_数组属性(plane, node);
	return plane;
}

void f_节点重置_数组属性(C_节点面板* plane, C_节点基类* node) {
	f_节点重构_面板重构(plane, node, E_节点区类型::e_节点区_节点视图);
	f_节点重构_插座重构(plane, node, E_节点区类型::e_节点区_节点视图);

	plane->m_属性面板参数构建 = f_数组属性节点_部件构建属性;
	plane->m_ICO = "icoVec3_1D0006";
}



static void f_取数组元素节点_部件构建属性(C_属性栏* plane, S_结构对象指针 obj) {
	C_取数组元素节点* node = dynamic_cast<C_取数组元素节点*>(((C_节点面板*)obj)->m_NodeData);
	std::vector<S_Props> props;
	f_节点重构_重构属性面板数据((C_节点面板*)obj, props);

	node->m_位置索引.m_UI->m_Update = on_属性改变更新节点_重新编译;
	props.push_back(node->m_位置索引);

	plane->f_构建属性部件(props);
}

C_节点面板* f_节点构建_取数组元素(S_UI创建环境& ctx, S_设备环境& ctx_3d, C_节点基类* node, C_节点树* tree) {
	if (!node) node = new C_取数组元素节点(ctx_3d);
	C_节点面板* plane = new C_节点面板(node, ctx, E_节点区类型::e_节点区_物体);
	f_节点重置_取数组元素(plane, node);
	return plane;
}

void f_节点重置_取数组元素(C_节点面板* plane, C_节点基类* node) {
	f_节点重构_面板重构(plane, node, E_节点区类型::e_节点区_节点视图);
	f_节点重构_插座重构(plane, node, E_节点区类型::e_节点区_节点视图);

	plane->m_属性面板参数构建 = f_取数组元素节点_部件构建属性;
	plane->m_ICO = "icoVec3_1D0006";
}



static void f_取数组头尾元素节点_部件构建属性(C_属性栏* plane, S_结构对象指针 obj) {
	C_取数组头尾元素节点* node = dynamic_cast<C_取数组头尾元素节点*>(((C_节点面板*)obj)->m_NodeData);
	std::vector<S_Props> props;
	f_节点重构_重构属性面板数据((C_节点面板*)obj, props);

	node->m_位置索引.m_UI->m_Update = on_属性改变更新节点_重新编译;
	props.push_back(node->m_位置索引);

	plane->f_构建属性部件(props);
}

C_节点面板* f_节点构建_取数组头尾元素(S_UI创建环境& ctx, S_设备环境& ctx_3d, C_节点基类* node, C_节点树* tree) {
	if (!node) {
		node = new C_取数组头尾元素节点(ctx_3d);
		node->m_ICO = "icoVec3_1D0006";
	}
	C_节点面板* plane = new C_节点面板(node, ctx, E_节点区类型::e_节点区_物体);
	f_节点重置_取数组头尾元素(plane, node);
	return plane;
}

void f_节点重置_取数组头尾元素(C_节点面板* plane, C_节点基类* node) {
	f_节点重构_面板插座重构(plane, node, E_节点区类型::e_节点区_节点视图);
	plane->m_属性面板参数构建 = f_取数组头尾元素节点_部件构建属性;
	plane->m_ICO = node->m_ICO;
}



static void f_查找数组元素节点_部件构建属性(C_属性栏* plane, S_结构对象指针 obj) {
	C_查找数组元素节点* node = dynamic_cast<C_查找数组元素节点*>(((C_节点面板*)obj)->m_NodeData);
	std::vector<S_Props> props;
	f_节点重构_重构属性面板数据((C_节点面板*)obj, props);
	plane->f_构建属性部件(props);
}

C_节点面板* f_节点构建_查找数组元素(S_UI创建环境& ctx, S_设备环境& ctx_3d, C_节点基类* node, C_节点树* tree) {
	if (!node) {
		node = new C_查找数组元素节点(ctx_3d);
		node->m_ICO = "icoVec3_1D0006";
	}
	C_节点面板* plane = new C_节点面板(node, ctx, E_节点区类型::e_节点区_物体);
	f_节点重置_查找数组元素(plane, node);
	return plane;
}

void f_节点重置_查找数组元素(C_节点面板* plane, C_节点基类* node) {
	f_节点重构_面板插座重构(plane, node, E_节点区类型::e_节点区_节点视图);
	plane->m_属性面板参数构建 = f_查找数组元素节点_部件构建属性;
	plane->m_ICO = node->m_ICO;
}



static void f_删除数组元素节点_部件构建属性(C_属性栏* plane, S_结构对象指针 obj) {
	C_删除数组元素节点* node = dynamic_cast<C_删除数组元素节点*>(((C_节点面板*)obj)->m_NodeData);
	std::vector<S_Props> props;
	f_节点重构_重构属性面板数据((C_节点面板*)obj, props);
	plane->f_构建属性部件(props);
}

C_节点面板* f_节点构建_删除数组元素(S_UI创建环境& ctx, S_设备环境& ctx_3d, C_节点基类* node, C_节点树* tree) {
	if (!node) {
		node = new C_删除数组元素节点(ctx_3d);
		node->m_ICO = "icoVec3_1D0006";
	}
	C_节点面板* plane = new C_节点面板(node, ctx, E_节点区类型::e_节点区_物体);
	f_节点重置_删除数组元素(plane, node);
	return plane;
}

void f_节点重置_删除数组元素(C_节点面板* plane, C_节点基类* node) {
	f_节点重构_面板插座重构(plane, node, E_节点区类型::e_节点区_节点视图);
	plane->m_属性面板参数构建 = f_删除数组元素节点_部件构建属性;
	plane->m_ICO = node->m_ICO;
}



static void f_取内存邻接数据节点_部件构建属性(C_属性栏* plane, S_结构对象指针 obj) {
	C_取内存邻接数据节点* node = dynamic_cast<C_取内存邻接数据节点*>(((C_节点面板*)obj)->m_NodeData);
	std::vector<S_Props> props;
	f_节点重构_重构属性面板数据((C_节点面板*)obj, props);
	plane->f_构建属性部件(props);
}

C_节点面板* f_节点构建_取内存邻接数据(S_UI创建环境& ctx, S_设备环境& ctx_3d, C_节点基类* node, C_节点树* tree) {
	if (!node) {
		node = new C_取内存邻接数据节点(ctx_3d);
		node->m_ICO = "icoVec3_1D0006";
	}
	C_节点面板* plane = new C_节点面板(node, ctx, E_节点区类型::e_节点区_物体);
	f_节点重置_取内存邻接数据(plane, node);
	return plane;
}

void f_节点重置_取内存邻接数据(C_节点面板* plane, C_节点基类* node) {
	f_节点重构_面板重构(plane, node, E_节点区类型::e_节点区_节点视图);
	f_节点重构_插座重构(plane, node, E_节点区类型::e_节点区_节点视图);

	plane->m_属性面板参数构建 = f_取内存邻接数据节点_部件构建属性;
	plane->m_ICO = node->m_ICO;
}



static void f_插入数组节点_部件构建属性(C_属性栏* plane, S_结构对象指针 obj) {
	C_插入数组节点* node = dynamic_cast<C_插入数组节点*>(((C_节点面板*)obj)->m_NodeData);
	std::vector<S_Props> props;
	f_节点重构_重构属性面板数据((C_节点面板*)obj, props);
	plane->f_构建属性部件(props);
}

C_节点面板* f_节点构建_插入数组节点(S_UI创建环境& ctx, S_设备环境& ctx_3d, C_节点基类* node, C_节点树* tree) {
	if (!node) {
		node = new C_插入数组节点(ctx_3d);
		node->m_ICO = "icoVec3_1D0006";
	}
	C_节点面板* plane = new C_节点面板(node, ctx, E_节点区类型::e_节点区_物体);
	f_节点重置_插入数组节点(plane, node);
	return plane;
}

void f_节点重置_插入数组节点(C_节点面板* plane, C_节点基类* node) {
	f_节点重构_面板插座重构(plane, node, E_节点区类型::e_节点区_节点视图);
	plane->m_属性面板参数构建 = f_插入数组节点_部件构建属性;
	plane->m_ICO = node->m_ICO;
}




static void f_VecSphere变量节点_部件构建属性(C_属性栏* plane, S_结构对象指针 obj) {
	C_vec球数组节点* node = dynamic_cast<C_vec球数组节点*>(((C_节点面板*)obj)->m_NodeData);

	std::vector<S_Props> props;
	f_节点重构_重构属性面板数据((C_节点面板*)obj, props);

	node->m_是否随机.m_UI->m_Update = on_属性改变更新节点;
	props.push_back(node->m_是否随机);

	plane->f_构建属性部件(props);
}

C_节点面板* f_节点构建_VecSphere数组变量(S_UI创建环境& ctx, S_设备环境& view_ctx, C_节点基类* node, C_节点树* tree) {
	if (!node) node = new C_vec球数组节点(view_ctx);
	C_节点面板* plane = new C_节点面板(node, ctx, E_节点区类型::e_节点区_物体);
	f_节点重置_VecSphere数组变量(plane, node);
	return plane;
}

void f_节点重置_VecSphere数组变量(C_节点面板* plane, C_节点基类* node) {
	C_vec球数组节点* v = dynamic_cast<C_vec球数组节点*>(node);

	f_节点重构_面板重构(plane, node, E_节点区类型::e_节点区_节点视图);
	f_节点重构_插座重构(plane, node, E_节点区类型::e_节点区_节点视图);

	plane->m_属性面板参数构建 = f_VecSphere变量节点_部件构建属性;
	plane->m_3D视口更新 = nullptr;
	plane->m_ICO = "icoVecSphere0007";
}








static void f_合并数据节点_部件构建属性(C_属性栏* plane, S_结构对象指针 obj) {
	C_合并数据节点* node = dynamic_cast<C_合并数据节点*>(((C_节点面板*)obj)->m_NodeData);

	std::vector<S_Props> props;
	f_节点重构_重构属性面板数据((C_节点面板*)obj, props);

	plane->f_构建属性部件(props);
	plane->m_绘制属性更新 = true;
}

C_节点面板* f_节点构建_合并数据(S_UI创建环境& ctx, S_设备环境& view_ctx, C_节点基类* node, C_节点树* tree) {
	if (!node) node = new C_合并数据节点(view_ctx);
	C_节点面板* plane = new C_节点面板(node, ctx, E_节点区类型::e_节点区_物体);
	f_节点重置_合并数据(plane, node);

	return plane;
}

void f_节点重置_合并数据(C_节点面板* plane, C_节点基类* node) {
	f_节点重构_面板重构(plane, node, E_节点区类型::e_节点区_节点视图);
	f_节点重构_插座重构(plane, node, E_节点区类型::e_节点区_节点视图);

	plane->m_属性面板参数构建 = f_合并数据节点_部件构建属性;
	plane->m_3D视口更新 = nullptr;
	plane->m_ICO = "ico合并数据0013";
}



static void f_复制数据节点_部件构建属性(C_属性栏* plane, S_结构对象指针 obj) {
	C_复制数组节点* node = dynamic_cast<C_复制数组节点*>(((C_节点面板*)obj)->m_NodeData);

	std::vector<S_Props> props;
	f_节点重构_重构属性面板数据((C_节点面板*)obj, props);

	plane->f_构建属性部件(props);
	plane->m_绘制属性更新 = true;
}

C_节点面板* f_节点构建_复制数据(S_UI创建环境& ctx, S_设备环境& ctx_3d, C_节点基类* node, C_节点树* tree) {
	if (!node) {
		node = new C_复制数组节点(ctx_3d);
		node->m_ICO = "icoVec3_1D0006";
	}
	C_节点面板* plane = new C_节点面板(node, ctx, E_节点区类型::e_节点区_物体);
	f_节点重置_复制数据(plane, node);
	return plane;
}

void f_节点重置_复制数据(C_节点面板* plane, C_节点基类* node) {
	f_节点重构_面板插座重构(plane, node, E_节点区类型::e_节点区_节点视图);
	plane->m_属性面板参数构建 = f_复制数据节点_部件构建属性;
	plane->m_ICO = node->m_ICO;
}



static void f_单值钳制节点_部件构建属性(C_属性栏* plane, S_结构对象指针 obj) {
	C_单值钳制节点* node = dynamic_cast<C_单值钳制节点*>(((C_节点面板*)obj)->m_NodeData);

	std::vector<S_Props> props;
	f_节点重构_重构属性面板数据((C_节点面板*)obj, props);

	node->m_区间.m_UI->m_Update = on_属性改变更新节点;
	props.push_back(node->m_区间);

	plane->f_构建属性部件(props);
}
C_节点面板* f_节点构建_单值钳制(S_UI创建环境& ctx, S_设备环境& ctx_3d, C_节点基类* node, C_节点树* tree) {
	if (!node) node = new C_单值钳制节点(ctx_3d);
	C_节点面板* plane = new C_节点面板(node, ctx, E_节点区类型::e_节点区_物体);
	f_节点重置_单值钳制(plane, node);
	return plane;
}

void f_节点重置_单值钳制(C_节点面板* plane, C_节点基类* node) {
	f_节点重构_面板重构(plane, node, E_节点区类型::e_节点区_节点视图);
	f_节点重构_插座重构(plane, node, E_节点区类型::e_节点区_节点视图);

	plane->m_属性面板参数构建 = f_单值钳制节点_部件构建属性;
	plane->m_3D视口更新 = nullptr;
	plane->m_ICO = "ico合并数据0013";
}



static void f_矢量钳制节点_部件构建属性(C_属性栏* plane, S_结构对象指针 obj) {
	C_矢量钳制节点* node = dynamic_cast<C_矢量钳制节点*>(((C_节点面板*)obj)->m_NodeData);

	std::vector<S_Props> props;
	f_节点重构_重构属性面板数据((C_节点面板*)obj, props);

	node->m_改变原数据.m_UI->m_Update = on_属性改变更新节点;
	props.push_back(node->m_改变原数据);

	plane->f_构建属性部件(props);
}

C_节点面板* f_节点构建_矢量钳制(S_UI创建环境& ctx, S_设备环境& ctx_3d, C_节点基类* node, C_节点树* tree) {
	if (!node) {
		node = new C_矢量钳制节点(ctx_3d);
		node->m_ICO = "icoVec3_1D0006";
	}
	C_节点面板* plane = new C_节点面板(node, ctx, E_节点区类型::e_节点区_物体);
	f_节点重置_矢量钳制(plane, node);
	return plane;
}
void f_节点重置_矢量钳制(C_节点面板* plane, C_节点基类* node) {
	f_节点重构_面板插座重构(plane, node, E_节点区类型::e_节点区_节点视图);
	plane->m_属性面板参数构建 = f_矢量钳制节点_部件构建属性;
	plane->m_ICO = node->m_ICO;
}




static void f_数组元素统计节点_部件构建属性(C_属性栏* plane, S_结构对象指针 obj) {
	C_数组元素统计节点* node = dynamic_cast<C_数组元素统计节点*>(((C_节点面板*)obj)->m_NodeData);

	std::vector<S_Props> props;
	f_节点重构_重构属性面板数据((C_节点面板*)obj, props);

	node->m_统计类型.m_UI->m_Update = on_属性改变更新节点;
	props.push_back(node->m_统计类型);

	plane->f_构建属性部件(props);
}

C_节点面板* f_节点构建_数组元素统计(S_UI创建环境& ctx, S_设备环境& ctx_3d, C_节点基类* node, C_节点树* tree) {
	if (!node) {
		node = new C_数组元素统计节点(ctx_3d);
		node->m_ICO = "icoVec3_1D0006";
	}
	C_节点面板* plane = new C_节点面板(node, ctx, E_节点区类型::e_节点区_物体);
	f_节点重置_数组元素统计(plane, node);
	return plane;
}

void f_节点重置_数组元素统计(C_节点面板* plane, C_节点基类* node) {
	f_节点重构_面板插座重构(plane, node, E_节点区类型::e_节点区_节点视图);
	plane->m_属性面板参数构建 = f_数组元素统计节点_部件构建属性;
	plane->m_ICO = node->m_ICO;
}




static void f_索引数组排序节点_部件构建属性(C_属性栏* plane, S_结构对象指针 obj) {
	C_索引数组排序节点* node = dynamic_cast<C_索引数组排序节点*>(((C_节点面板*)obj)->m_NodeData);

	std::vector<S_Props> props;
	f_节点重构_重构属性面板数据((C_节点面板*)obj, props);

	node->m_排序方式.m_UI->m_Update = on_属性改变更新节点;
	props.push_back(node->m_排序方式);

	node->m_排序算法.m_UI->m_Update = on_属性改变更新节点_重新编译;
	props.push_back(node->m_排序算法);

	//node->m_拷贝原数据.m_UI->m_Update = on_属性改变更新节点_重新编译;
	//props.push_back(node->m_拷贝原数据);

	plane->f_构建属性部件(props);
}

C_节点面板* f_节点构建_索引数组排序(S_UI创建环境& ctx, S_设备环境& ctx_3d, C_节点基类* node, C_节点树* tree) {
	if (!node) {
		node = new C_索引数组排序节点(ctx_3d);
		node->m_ICO = "icoVec3_1D0006";
	}
	C_节点面板* plane = new C_节点面板(node, ctx, E_节点区类型::e_节点区_物体);
	f_节点重置_索引数组排序(plane, node);
	return plane;
}

void f_节点重置_索引数组排序(C_节点面板* plane, C_节点基类* node) {
	f_节点重构_面板插座重构(plane, node, E_节点区类型::e_节点区_节点视图);
	plane->m_属性面板参数构建 = f_索引数组排序节点_部件构建属性;
	plane->m_ICO = node->m_ICO;
}



static void f_数组重排节点_部件构建属性(C_属性栏* plane, S_结构对象指针 obj) {
	C_数组重排节点* node = dynamic_cast<C_数组重排节点*>(((C_节点面板*)obj)->m_NodeData);

	std::vector<S_Props> props;
	f_节点重构_重构属性面板数据((C_节点面板*)obj, props);

	node->m_改变原数据.m_UI->m_Update = on_属性改变更新节点;
	props.push_back(node->m_改变原数据);

	plane->f_构建属性部件(props);
}

C_节点面板* f_节点构建_数组重排(S_UI创建环境& ctx, S_设备环境& ctx_3d, C_节点基类* node, C_节点树* tree) {
	if (!node) {
		node = new C_数组重排节点(ctx_3d);
		node->m_ICO = "icoVec3_1D0006";
	}
	C_节点面板* plane = new C_节点面板(node, ctx, E_节点区类型::e_节点区_物体);
	f_节点重置_数组重排(plane, node);
	return plane;
}

void f_节点重置_数组重排(C_节点面板* plane, C_节点基类* node) {
	f_节点重构_面板插座重构(plane, node, E_节点区类型::e_节点区_节点视图);
	plane->m_属性面板参数构建 = f_数组重排节点_部件构建属性;
	plane->m_ICO = node->m_ICO;
}



C_节点面板* f_节点构建_八叉树数据(S_UI创建环境& ctx, S_设备环境& view_ctx, C_节点基类* node, C_节点树* tree) {

	return nullptr;
}

void f_节点重置_八叉树数据(C_节点面板* plane, C_节点基类* node)
{
}









static void on_切换取成员数据(S_Props& prop) {
	auto nodes = f_global_get激活节点();
	for (auto 节点 : nodes) {
		节点->f_set是否要更新(true);
	}

	//switch ((*(S_PropValueEnum*)prop.m_Value).m_当前选项)
	//((C_节点面板*)f_global_get激活节点())->m_NodeData->f_set是否要更新(true);

}


static void f_转换数据节点_3D视口更新(C_节点面板* n, S_Scene* scene) {
	C_转换数据节点* node = dynamic_cast<C_转换数据节点*>(n->m_NodeData);
}

static void f_转换数据节点_部件构建属性(C_属性栏* plane, S_结构对象指针 obj) {
	C_转换数据节点* node = dynamic_cast<C_转换数据节点*>(((C_节点面板*)obj)->m_NodeData);

	std::vector<S_Props> props;
	f_节点重构_重构属性面板数据((C_节点面板*)obj, props);

	node->m_转换后类型.m_UI->m_Update = on_切换取成员数据;
	S_Props prop = node->m_转换后类型;
	prop.m_私有 = true;
	props.push_back(prop);

	plane->f_构建属性部件(props);

	f_转换数据节点_3D视口更新(((C_节点面板*)obj), nullptr);
}

C_节点面板* f_节点构建_转换数据(S_UI创建环境& ctx, S_设备环境& view_ctx, C_节点基类* node, C_节点树* tree) {
	if (!node) node = new C_转换数据节点(view_ctx);
	//if (plane == nullptr) {
	//	plane = f_节点创建_UI面板构建(ctx, node, E_节点区类型::e_节点区_节点视图);
	//}
	C_节点面板* plane = new C_节点面板(node, ctx, E_节点区类型::e_节点区_物体);
	f_节点重置_转换数据(plane, node);
	return plane;
}

void		f_节点重置_转换数据(C_节点面板* plane, C_节点基类* node) {
	f_节点重构_面板重构(plane, node, E_节点区类型::e_节点区_节点视图);
	f_节点重构_插座重构(plane, node, E_节点区类型::e_节点区_节点视图);

	plane->m_属性面板参数构建 = f_转换数据节点_部件构建属性;
	plane->m_3D视口更新 = f_转换数据节点_3D视口更新;
	plane->m_ICO = "ico转换0012";
}










static void f_取成员数据节点_3D视口更新(C_节点面板* n, S_Scene* scene) {
	C_取成员数据节点* node = dynamic_cast<C_取成员数据节点*>(n->m_NodeData);
}

static void f_取成员数据节点_部件构建属性(C_属性栏* plane, S_结构对象指针 obj) {
	C_取成员数据节点* node = dynamic_cast<C_取成员数据节点*>(((C_节点面板*)obj)->m_NodeData);

	std::vector<S_Props> props;
	f_节点重构_重构属性面板数据((C_节点面板*)obj, props);

	node->m_成员.m_UI->m_Update = on_切换取成员数据;
	S_Props prop = node->m_成员;
	prop.m_私有 = true;
	props.push_back(prop);

	plane->f_构建属性部件(props);

	f_转换数据节点_3D视口更新(((C_节点面板*)obj), nullptr);
}

C_节点面板* f_节点构建_取成员数据(S_UI创建环境& ctx, S_设备环境& view_ctx, C_节点基类* node, C_节点树* tree) {
	if (!node) node = new C_取成员数据节点(view_ctx);
	//if (plane == nullptr) {
	//	plane = f_节点创建_UI面板构建(ctx, node, E_节点区类型::e_节点区_节点视图);
	//}
	C_节点面板* plane = new C_节点面板(node, ctx, E_节点区类型::e_节点区_物体);
	f_节点重置_取成员数据(plane, node);
	return plane;
}

void		f_节点重置_取成员数据(C_节点面板* plane, C_节点基类* node) {
	f_节点重构_面板重构(plane, node, E_节点区类型::e_节点区_节点视图);
	f_节点重构_插座重构(plane, node, E_节点区类型::e_节点区_节点视图);

	plane->m_属性面板参数构建 = f_取成员数据节点_部件构建属性;
	plane->m_3D视口更新 = f_取成员数据节点_3D视口更新;
	plane->m_ICO = "ico取成员0011";
}









static void f_从坐标取数据节点_3D视口更新(C_节点面板* n, S_Scene* scene) {
	C_从坐标取数据节点* node = dynamic_cast<C_从坐标取数据节点*>(n->m_NodeData);
}

static void f_从坐标取数据节点_部件构建属性(C_属性栏* plane, S_结构对象指针 obj) {
	C_从坐标取数据节点* node = dynamic_cast<C_从坐标取数据节点*>(((C_节点面板*)obj)->m_NodeData);

	std::vector<S_Props> props;
	f_节点重构_重构属性面板数据((C_节点面板*)obj, props);

	node->m_成员.m_UI->m_Update = on_切换取成员数据;
	S_Props prop = node->m_成员;
	prop.m_私有 = true;
	props.push_back(prop);

	//props.push_back(f_alloc_UI32Prop(&DEF_UI32插座数据(node->f_get输入插座(1), 0), L"数组大小"));

	plane->f_构建属性部件(props);

	f_从坐标取数据节点_3D视口更新(((C_节点面板*)obj), nullptr);
}

C_节点面板* f_节点构建_坐标取数据(S_UI创建环境& ctx, S_设备环境& view_ctx, C_节点基类* node, C_节点树* tree) {
	if (!node) node = new C_从坐标取数据节点(view_ctx);
	//if (plane == nullptr) {
	//	plane = f_节点创建_UI面板构建(ctx, node, E_节点区类型::e_节点区_节点视图);
	//}
	C_节点面板* plane = new C_节点面板(node, ctx, E_节点区类型::e_节点区_物体);
	f_节点重置_坐标取数据(plane, node);
	return plane;
}

void f_节点重置_坐标取数据(C_节点面板* plane, C_节点基类* node) {
	f_节点重构_面板重构(plane, node, E_节点区类型::e_节点区_节点视图);
	f_节点重构_插座重构(plane, node, E_节点区类型::e_节点区_节点视图);

	plane->m_属性面板参数构建 = f_从坐标取数据节点_部件构建属性;
	plane->m_3D视口更新 = f_从坐标取数据节点_3D视口更新;
	plane->m_ICO = "ico取成员0011";
}



static void f_取空间邻接数据节点_部件构建属性(C_属性栏* plane, S_结构对象指针 obj) {
	C_取空间邻接数据节点* node = dynamic_cast<C_取空间邻接数据节点*>(((C_节点面板*)obj)->m_NodeData);

	std::vector<S_Props> props;
	f_节点重构_重构属性面板数据((C_节点面板*)obj, props);

	node->m_空间类型.m_UI->m_Update = on_属性改变更新节点_重新编译;
	props.push_back(node->m_空间类型);

	plane->f_构建属性部件(props);
}

C_节点面板* f_节点构建_取空间邻接数据(S_UI创建环境& ctx, S_设备环境& ctx_3d, C_节点基类* node, C_节点树* tree) {
	if (!node) {
		node = new C_取空间邻接数据节点(ctx_3d);
		node->m_ICO = "ico取成员0011";
	}
	C_节点面板* plane = new C_节点面板(node, ctx, E_节点区类型::e_节点区_物体);
	f_节点重置_取空间邻接数据(plane, node);
	return plane;
}

void f_节点重置_取空间邻接数据(C_节点面板* plane, C_节点基类* node) {
	f_节点重构_面板插座重构(plane, node, E_节点区类型::e_节点区_节点视图);
	plane->m_属性面板参数构建 = f_取空间邻接数据节点_部件构建属性;
	plane->m_ICO = node->m_ICO;
}




static void f_合并数组节点_部件构建属性(C_属性栏* plane, S_结构对象指针 obj) {
	C_合并数组元素节点* node = dynamic_cast<C_合并数组元素节点*>(((C_节点面板*)obj)->m_NodeData);

	std::vector<S_Props> props;
	f_节点重构_重构属性面板数据((C_节点面板*)obj, props);
	plane->f_构建属性部件(props);
}

C_节点面板* f_节点构建_合并数组(S_UI创建环境& ctx, S_设备环境& ctx_3d, C_节点基类* node, C_节点树* tree) {
	if (!node) {
		node = new C_合并数组元素节点(ctx_3d);
		node->m_ICO = "ico取成员0011";
	}
	C_节点面板* plane = new C_节点面板(node, ctx, E_节点区类型::e_节点区_物体);
	f_节点重置_合并数组(plane, node);
	return plane;
}

void f_节点重置_合并数组(C_节点面板* plane, C_节点基类* node) {
	f_节点重构_面板插座重构(plane, node, E_节点区类型::e_节点区_节点视图);
	plane->m_属性面板参数构建 = f_合并数组节点_部件构建属性;
	plane->m_ICO = node->m_ICO;
}



static void f_数组打乱节点_部件构建属性(C_属性栏* plane, S_结构对象指针 obj) {
	C_数组打乱节点* node = dynamic_cast<C_数组打乱节点*>(((C_节点面板*)obj)->m_NodeData);

	std::vector<S_Props> props;
	f_节点重构_重构属性面板数据((C_节点面板*)obj, props);

	node->m_拷贝原数据.m_UI->m_Update = on_切换取成员数据;
	S_Props prop = node->m_拷贝原数据;
	props.push_back(prop);

	plane->f_构建属性部件(props);
}

C_节点面板* f_节点构建_数组打乱(S_UI创建环境& ctx, S_设备环境& ctx_3d, C_节点基类* node, C_节点树* tree) {
	if (!node) {
		node = new C_数组打乱节点(ctx_3d);
		node->m_ICO = "ico取成员0011";
	}
	C_节点面板* plane = new C_节点面板(node, ctx, E_节点区类型::e_节点区_物体);
	f_节点重置_数组打乱(plane, node);
	return plane;
}

void f_节点重置_数组打乱(C_节点面板* plane, C_节点基类* node) {
	f_节点重构_面板插座重构(plane, node, E_节点区类型::e_节点区_节点视图);
	plane->m_属性面板参数构建 = f_数组打乱节点_部件构建属性;
	plane->m_ICO = node->m_ICO;
}





static void f_数组抽取节点_部件构建属性(C_属性栏* plane, S_结构对象指针 obj) {
	C_数组抽取节点* node = dynamic_cast<C_数组抽取节点*>(((C_节点面板*)obj)->m_NodeData);

	std::vector<S_Props> props;
	f_节点重构_重构属性面板数据((C_节点面板*)obj, props);

	node->m_抽取方式.m_UI->m_Update = on_属性改变更新节点;
	props.push_back(node->m_抽取方式);
	node->m_改变原数据.m_UI->m_Update = on_属性改变更新节点_重新编译;
	props.push_back(node->m_改变原数据);

	plane->f_构建属性部件(props);
}

C_节点面板* f_节点构建_数组抽取(S_UI创建环境& ctx, S_设备环境& ctx_3d, C_节点基类* node, C_节点树* tree) {
	if (!node) {
		node = new C_数组抽取节点(ctx_3d);
		node->m_ICO = "ico取成员0011";
	}
	C_节点面板* plane = new C_节点面板(node, ctx, E_节点区类型::e_节点区_物体);
	f_节点重置_数组抽取(plane, node);
	return plane;
}

void f_节点重置_数组抽取(C_节点面板* plane, C_节点基类* node) {
	f_节点重构_面板插座重构(plane, node, E_节点区类型::e_节点区_节点视图);
	plane->m_属性面板参数构建 = f_数组抽取节点_部件构建属性;
	plane->m_ICO = node->m_ICO;
}


















